/**
 * Generali Solutions d'assurances - Tous droits rï¿½servï¿½s &copy; 2007 - 2010
 */
package fr.generali.accueilclient.resume.contrat.services.impl;

import java.util.List;

import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.core.convert.converter.Converter;
import org.springframework.stereotype.Service;

import fr.generali.accueilclient.client.om.IPersonne;
import fr.generali.accueilclient.commun.exception.AccueilClientBusinessException;
import fr.generali.accueilclient.commun.exception.AccueilClientTechnicalException;
import fr.generali.accueilclient.contrat.om.IConsultContrat;
import fr.generali.accueilclient.resume.contrat.om.IEnvironnementLie;
import fr.generali.accueilclient.resume.contrat.om.IResumeContrat;
import fr.generali.accueilclient.resume.contrat.services.IResumeContratService;
import fr.generali.refservcommuns.rce.liste.contrats.services.IConsultationContratListePersonneWebService;
import fr.generali.refservcommuns.rce.liste.contrats.services.ResumeWSBusinessException;
import fr.generali.refservcommuns.rce.liste.contrats.services.TechnicalFault;
import fr.generali.refservcommuns.rce.liste.contrats.consultationcontratpersonneservice.ListeDossierContrat;

/**
 * Implï¿½mentation de {@link IResumeContratService}
 * 
 * @author Guillaume Lancelin
 */
@Service("resumeContratService")
public class ResumeContratService implements IResumeContratService {

    /**
     * LOGGER
     */
    private static final Logger LOGGER = LoggerFactory.getLogger(ResumeContratService.class);

    /**
     * Le service RCE de consultation des rï¿½sumï¿½s contrat (S14)
     */
    @Autowired
    @Qualifier("S14")
    private IConsultationContratListePersonneWebService consultationContratListePersonneService;

    /**
     * L'assembler
     */
    @Autowired
    @Qualifier("environnementLie2ListeDossierContratConverter")
    private Converter<IEnvironnementLie, ListeDossierContrat> environnementLie2ListeDossierContratConverter;

    /**
     * L'assembler
     */
    @Autowired
    @Qualifier("personne2ListeDossierContratConverter")
    private Converter<IPersonne, ListeDossierContrat> personne2ListeDossierContratConverter;

    /**
     * Classe permettant de mapper les rï¿½sultats des appels aux webservices
     */
    @Autowired
    private ResumeContratServiceMapper resumeContratServiceMapper;

    /**
     * Classe permettant de mapper les resultats des appels aux webservices
     */
    @Autowired
    private ConsultContratServiceMapper consultContratServiceMapper;

    /**
     * {@inheritDoc}
     */
    public List<IResumeContrat> consulterListeContratParIdClient(IEnvironnementLie environnementLie)
                    throws AccueilClientBusinessException {
        List<IResumeContrat> resultats = null;
        try {
            ListeDossierContrat listeDossierContrat =
                            environnementLie2ListeDossierContratConverter.convert(environnementLie);

            if (listeDossierContrat != null) {

                ListeDossierContrat resultatAvecInfosClient =
                                consultationContratListePersonneService.consulterContratListePersonneAvecInfosClient(
                                                listeDossierContrat, null);

                resultats =
                                resumeContratServiceMapper
                                                .mapperConsultationListeContratParIdClient(resultatAvecInfosClient);
            }

        } catch (ResumeWSBusinessException e) {
            LOGGER.debug("Erreur business lors de l'appel au resume contrat RCE: '{}'.", e.getMessage());
            throw new AccueilClientBusinessException(e.getMessage(), e);
        } catch (TechnicalFault e) {
            LOGGER.error("Erreur technique lors de l'appel au resume contrat RCE: '{}'.", e.getMessage());
            throw new AccueilClientTechnicalException(e.getMessage(), e.getMessage(), e);
        }

        return resultats;
    }

    /**
     * {@inheritDoc}
     */
    public List<IConsultContrat> consulterListeContratLiesClient(IPersonne client)
                    throws AccueilClientBusinessException {
        List<IConsultContrat> resultats = null;
        try {
            ListeDossierContrat listeDossierContrat = personne2ListeDossierContratConverter.convert(client);

            if (listeDossierContrat != null && CollectionUtils.isNotEmpty(listeDossierContrat.getDossierContrat())) {

                ListeDossierContrat listeContrats =
                                consultationContratListePersonneService.consulterContratListePersonneAvecInfosClient(
                                                listeDossierContrat, null);

                resultats = consultContratServiceMapper.mapperConsultationListeContratParIdClient(listeContrats);
            }

        } catch (ResumeWSBusinessException e) {
            LOGGER.debug("Erreur business lors de l'appel au resume contrat RCE: '{}'.", e.getMessage());
            throw new AccueilClientBusinessException(e.getMessage(), e);
        } catch (TechnicalFault e) {
            LOGGER.error("Erreur technique lors de l'appel au resume contrat RCE: '{}'.", e.getMessage());
            throw new AccueilClientTechnicalException(e.getMessage(), e.getMessage(), e);
        }

        return resultats;
    }

    /**
     * {@inheritDoc}
     */
    public List<IConsultContrat> consulterResumeListeContratLiesClient(IPersonne client) {

        List<IConsultContrat> listeContrats = null;

        if (CollectionUtils.isNotEmpty(client.getContrats())) {
            listeContrats = consultContratServiceMapper.mapperResumeContratToConsultContrat(client.getContrats());
        }

        return listeContrats;
    }
}
